home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / visulztn / saoimage / saoimage.lha / mgfymark.c < prev    next >
C/C++ Source or Header  |  1990-04-20  |  5KB  |  201 lines
  1. #ifndef lint
  2. static char SccsId[] = "%W%  %G%";
  3. #endif
  4.  
  5. /* Module:    mgfymark.c (Magnify Mark)
  6.  * Purpose:    Quickly put the sighting mark in the magnified image
  7.  * Subroutine:    init_magnifier_Zmark()        returns: void
  8.  * Subroutine:    mark_magnifierZ()        returns: void
  9.  * Subroutine:    init_magnifier_XYmark()        returns: void
  10.  * Subroutine:    mark_magnifierXY()        returns: void
  11.  * Copyright:    1989 Smithsonian Astrophysical Observatory
  12.  *        You may do anything you like with this file except remove
  13.  *        this copyright.  The Smithsonian Astrophysical Observatory
  14.  *        makes no representations about the suitability of this
  15.  *        software for any purpose.  It is provided "as is" without
  16.  *        express or implied warranty.
  17.  * Modified:    {0} Michael VanHilst    initial version         6 June 1989
  18.  *        {n} <who> -- <does what> -- <when>
  19.  */
  20.  
  21. #include <X11/Xlib.h>        /* X window stuff */
  22. #include <X11/Xutil.h>        /* X window manager stuff */
  23. #include "hfiles/color.h"    /* define GCspec */
  24. #include "hfiles/magnify.h"    /* magnifier quick access structure */
  25. #include "defs/magnify.def"    /* masks for sighting mark */
  26.  
  27. extern struct magRec magset;
  28.  
  29. struct {
  30.   char *top_left;
  31.   char *top_right;
  32.   char *bot_left;
  33.   char *bot_right;
  34.   int tl_br_next;
  35.   int tr_bl_next;
  36. } Zmark;
  37.  
  38. /*
  39.  * Subroutine:    init_magnifier_Zmark
  40.  */
  41. void init_magnifier_Zmark ( )
  42. {
  43.   char *line_center;
  44.  
  45.   line_center = magset.data + magset.data_x_hot +
  46.     ((magset.data_y_hot - Zmark_y_hot) * magset.win.width);
  47.   Zmark.top_left = line_center - Zmark_x_hot;
  48.   Zmark.top_right = line_center + Zmark_x_hot;
  49.   line_center = magset.data + magset.data_x_hot +
  50.     ((magset.data_y_hot + Zmark_y_hot) * magset.win.width);
  51.   Zmark.bot_left = line_center - Zmark_x_hot;
  52.   Zmark.bot_right = line_center + Zmark_x_hot;
  53.   Zmark.tl_br_next = magset.win.width - Zmark_x_hot;
  54.   Zmark.tr_bl_next = magset.win.width + Zmark_x_hot;
  55. }
  56.  
  57. /*
  58.  * Subroutine:    mark_Zmagnifier
  59.  */
  60. void mark_Zmagnifier ( )
  61. {
  62.   register char *top_left, *top_right;
  63.   register char *bot_left, *bot_right;
  64.   register int *mark;
  65.   register int foreground, background;
  66.  
  67.   top_left = Zmark.top_left;
  68.   bot_left = Zmark.bot_left;
  69.   top_right = Zmark.top_right;
  70.   bot_right = Zmark.bot_right;
  71.   foreground = magset.gcset_aim->foreground;
  72.   background = magset.gcset_aim->background;
  73.   mark = (int *)Zmark_mask;
  74.   while( top_left < bot_left ) {
  75.     while( top_left < top_right ) {
  76.       if( *mark ) {
  77.     if( *mark > 1 ) {
  78.       *top_left = foreground;
  79.       *top_right = foreground;
  80.       *bot_left = foreground;
  81.       *bot_right = foreground;
  82.     } else {
  83.       *top_left = background;
  84.       *top_right = background;
  85.       *bot_left = background;
  86.       *bot_right = background;
  87.     }
  88.       }
  89.       mark++;
  90.       top_left++;
  91.       top_right--;
  92.       bot_left++;
  93.       bot_right--;
  94.     }
  95.     /* pointers converge at center, just do left */
  96.     if( *mark ) {
  97.       if( *mark > 1 ) {
  98.     *top_left = foreground;
  99.     *bot_left = foreground;
  100.       } else {
  101.     *top_left = background;
  102.     *bot_left = background;
  103.       }
  104.     }
  105.     mark++;
  106.     top_left += Zmark.tl_br_next;
  107.     bot_right -= Zmark.tl_br_next;
  108.     top_right += Zmark.tr_bl_next;
  109.     bot_left -= Zmark.tr_bl_next;
  110.   }
  111.   /* pointers converge on middle line, just do top */
  112.   while( top_left < top_right ) {
  113.     if( *mark ) {
  114.       if( *mark > 1 ) {
  115.     *top_left = foreground;
  116.     *top_right = foreground;
  117.       } else {
  118.     *top_left = background;
  119.     *top_right = background;
  120.       }
  121.     }
  122.     mark++;
  123.     top_left++;
  124.     top_right--;
  125.   }
  126.   /* pointers converge at center, just do left */
  127.   if( *mark ) {
  128.     if( *mark > 1 ) {
  129.       *top_left = foreground;
  130.     } else {
  131.       *top_left = background;
  132.     }
  133.   }
  134. }
  135.  
  136. struct {
  137.   char *top_left;
  138.   char *mark;
  139.   char *mask;
  140.   char *last_mark;
  141.   int bytes;
  142.   int next_line;
  143. } XYmark;
  144.  
  145. /*
  146.  * Subroutine:    init_magnifier_XYmark
  147.  */
  148. void init_magnifier_XYmark ( )
  149. {
  150.   int xoff;
  151.  
  152.   xoff = magset.data_x_hot - XYmark_x_hot;
  153.   XYmark.top_left = magset.data + (xoff / 8) +
  154.     ((magset.data_y_hot - XYmark_y_hot) * magset.bytes_per_line);
  155.   xoff = xoff & 7; 
  156.   XYmark.mark = XYmark_mark[xoff] - 1;
  157.   XYmark.mask = XYmark_mask[xoff] - 1;
  158.   if( xoff < 4 ) {
  159.     XYmark.bytes = 2;
  160.     XYmark.next_line = magset.bytes_per_line - 1;
  161.     XYmark.last_mark = XYmark.mark + 26;
  162.   } else {
  163.     XYmark.bytes = 3;
  164.     XYmark.next_line = magset.bytes_per_line - 2;
  165.     XYmark.last_mark = XYmark.mark + 39;
  166.   }
  167. }
  168.  
  169. /*
  170.  * Subroutine:    mark_XYmagnifier
  171.  */
  172. void mark_XYmagnifier ( )
  173. {
  174.   register unsigned char *data, *mark, *mask, *last_mark;
  175.   register int next_line;
  176.  
  177.   data = (unsigned char *)XYmark.top_left;
  178.   mark = (unsigned char *)XYmark.mark;
  179.   mask = (unsigned char *)XYmark.mask;
  180.   last_mark = (unsigned char *)XYmark.last_mark;
  181.   next_line = XYmark.next_line;
  182.  
  183.   if( XYmark.bytes == 2 ) {
  184.     while( mark < last_mark ) {
  185.       *data = (*data & *(++mask)) | *(++mark);
  186.       data++;
  187.       *data = (*data & *(++mask)) | *(++mark);
  188.       data += next_line;
  189.     }
  190.   } else {
  191.     while( mark < last_mark ) {
  192.       *data = (*data & *(++mask)) | *(++mark);
  193.       data++;
  194.       *data = ((*data & *(++mask)) | *(++mark));
  195.       data++;
  196.       *data = (*data & *(++mask)) | *(++mark);
  197.       data += next_line;
  198.     }
  199.   }
  200. }
  201.